home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / util1 / yk211src.lha / Yak_2.11_Src / Prefs / Keydef.c < prev    next >
C/C++ Source or Header  |  1995-11-16  |  8KB  |  345 lines
  1.  
  2. #include <exec/types.h>
  3. #include <libraries/commodities.h>
  4. #include <proto/keymap.h>
  5. #include <string.h>
  6.  
  7. #include "code.h"
  8. #include "yak.h"
  9. #include "handlers.h"
  10. #include "gui.h"
  11. #include "keydef.h"
  12. #include "Keydef_window.h"
  13.  
  14.  
  15. UBYTE ParentWindowID;   /* Identifier of the parent window to switch back */
  16.  
  17.  
  18. #define QUALIFIERS_NUMBER 13
  19. static const struct QualifierArrayType QualifierArray[] =
  20. {
  21.     {IEQUALIFIER_CONTROL,    "Control"},
  22.     {IEQUALIFIER_LSHIFT,     "LShift"},
  23.     {IEQUALIFIER_RSHIFT,     "RShift"},
  24.     {IEQUALIFIER_CAPSLOCK,   "CapsLock"},
  25.     {IEQUALIFIER_LALT,       "LAlt"},
  26.     {IEQUALIFIER_RALT,       "RAlt"},
  27.     {IEQUALIFIER_LCOMMAND,   "LCommand"},
  28.     {IEQUALIFIER_RCOMMAND,   "RCommand"},
  29.     {IEQUALIFIER_LEFTBUTTON, "LeftButton"},
  30.     {IEQUALIFIER_MIDBUTTON,  "MidButton"},
  31.     {IEQUALIFIER_RBUTTON,    "RButton"},
  32.     {IEQUALIFIER_REPEAT,     "Repeat"},
  33.     {IEQUALIFIER_NUMERICPAD, "NumericPad"}
  34. };
  35.  
  36.  
  37. #define SAMEQUALIFIERS_NUMBER 3
  38. static const struct QualifierArrayType SameQualifierArray[] =
  39. {
  40.     {IXSYM_SHIFTMASK, "Shift"},
  41.     {IXSYM_CAPSMASK,  "Caps"},
  42.     {IXSYM_ALTMASK,   "Alt"}
  43. };
  44.  
  45.  
  46. #define QUALIFIERSPAD_NUMBER 9
  47. static const struct QualifierPadArrayType QualifierPadArray[] =
  48. {
  49.     {0x60, IEQUALIFIER_LSHIFT},
  50.     {0x61, IEQUALIFIER_RSHIFT},
  51.     {0x62, IEQUALIFIER_CAPSLOCK},      /* CapsLock down */
  52.     {0xe2, IEQUALIFIER_CAPSLOCK},      /* CapsLock up */
  53.     {0x63, IEQUALIFIER_CONTROL},
  54.     {0x64, IEQUALIFIER_LALT},
  55.     {0x65, IEQUALIFIER_RALT},
  56.     {0x66, IEQUALIFIER_LCOMMAND},
  57.     {0x67, IEQUALIFIER_RCOMMAND}
  58. };
  59.  
  60.  
  61. #define CODES_NUMBER 31
  62. static const struct CodeArrayType CodeArray[] =
  63. {
  64.     {0x38,      "Comma"},
  65.     {0x40,      "Space"},
  66.     {0x41,      "BackSpace"},
  67.     {0x42,      "Tab"},
  68.     {0x43,      "Enter"},
  69.     {0x44,      "Return"},
  70.     {0x45,      "Esc"},
  71.     {0x46,      "Del"},
  72.     {0x47,      "Insert"},
  73.     {0x48,      "Page_Up"},
  74.     {0x49,      "Page_Down"},
  75.     {0x4C,      "Up"},
  76.     {0x4D,      "Down"},
  77.     {0x4E,      "Right"},
  78.     {0x4F,      "Left"},
  79.     {0x50,      "F1"},
  80.     {0x51,      "F2"},
  81.     {0x52,      "F3"},
  82.     {0x53,      "F4"},
  83.     {0x54,      "F5"},
  84.     {0x55,      "F6"},
  85.     {0x56,      "F7"},
  86.     {0x57,      "F8"},
  87.     {0x58,      "F9"},
  88.     {0x59,      "F10"},
  89.     {0x5F,      "Help"},
  90.     {0x68,      "Mouse_LeftPress"},
  91.     {0x69,      "Mouse_RightPress"},
  92.     {0x6A,      "Mouse_MiddlePress"},
  93.     {0x70,      "Home"},
  94.     {0x71,      "End"}
  95. };
  96.  
  97.  
  98. const STRPTR ClassArray[] =
  99. {
  100.     "RawKey",
  101.     "RawMouse",
  102.     "DiskInserted",
  103.     "DiskRemoved"
  104. };
  105.  
  106.  
  107. const STRPTR StrokeArray[] =
  108. {
  109.     "",
  110.     " upstroke",
  111.     " -upstroke"
  112. };
  113.  
  114.  
  115.  
  116.  
  117. static __regargs void
  118. ConvertQualifiers(UWORD qual, UWORD iqual, UWORD squal, char *qualstr)
  119. {
  120.     UWORD i;
  121.  
  122.     *qualstr = '\0';
  123.  
  124.     for (i=0; i<SAMEQUALIFIERS_NUMBER; i++)
  125.     {
  126.         if ((qual & squal & SameQualifierArray[i].qat_ID) == SameQualifierArray[i].qat_ID)
  127.         {
  128.            *qualstr++ = ' ';
  129.            qualstr = stpcpy(qualstr, SameQualifierArray[i].qat_Str);
  130.         }
  131.         if ((iqual & squal & SameQualifierArray[i].qat_ID) == SameQualifierArray[i].qat_ID)
  132.         {
  133.            *qualstr++ = ' ';
  134.            *qualstr++ = '-';
  135.            qualstr = stpcpy(qualstr, SameQualifierArray[i].qat_Str);
  136.         }
  137.  
  138.     }
  139.  
  140.     qual  &= ~squal;
  141.     iqual &= ~squal;
  142.     for (i=0; i<QUALIFIERS_NUMBER; i++)
  143.     {
  144.         if (qual & QualifierArray[i].qat_ID)
  145.         {
  146.            *qualstr++ = ' ';
  147.            qualstr = stpcpy(qualstr, QualifierArray[i].qat_Str);
  148.         }
  149.         if (iqual & QualifierArray[i].qat_ID)
  150.         {
  151.            *qualstr++ = ' ';
  152.            *qualstr++ = '-';
  153.            qualstr = stpcpy(qualstr, QualifierArray[i].qat_Str);
  154.         }
  155.     }
  156. }
  157.  
  158.  
  159. static __regargs BOOL
  160. ConvertCode(UWORD code, char *codestr)
  161. {
  162.   *codestr = '\0';
  163.  
  164.   if (code != NO_IECODE)
  165.   {
  166.       struct InputEvent ievent;
  167.       UWORD  i;
  168.  
  169.       for (i=0; i<CODES_NUMBER; i++)
  170.       {
  171.           if (code == CodeArray[i].cat_Code)
  172.           {
  173.               codestr[0] = ' ';
  174.               strcpy(codestr+1, CodeArray[i].cat_Str);
  175.               return TRUE;
  176.           }
  177.  
  178.       }
  179.  
  180.       ievent.ie_Class         = IECLASS_RAWKEY;
  181.       ievent.ie_Code          = code;
  182.       ievent.ie_Qualifier     = NO_IEQUALIFIER;
  183.       ievent.ie_Prev1DownCode = ievent.ie_Prev1DownQual = NO_IEQUALIFIER;
  184.       ievent.ie_Prev2DownCode = ievent.ie_Prev2DownQual = NO_IEQUALIFIER;
  185.  
  186.       if((MapRawKey(&ievent, codestr+1, 1, NULL) == 1) &&
  187.          (codestr[1] != '-'))             /* forbidden */
  188.       {
  189.           codestr[0] = ' ';
  190.           codestr[2] = '\0';
  191.           return TRUE;
  192.       }
  193.   }
  194.  
  195.   return FALSE;
  196. }
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203. __regargs BOOL
  204. BuildKeyDef(YakKeyDef *ykd, STRPTR desc)
  205. {
  206.     BOOL  ret;
  207.     UBYTE codestr[20], qualstr[110];
  208.  
  209.     ConvertQualifiers(ykd->ykd_Qual, ykd->ykd_IQual, ykd->ykd_SQual, qualstr);
  210.  
  211.     switch (ykd->ykd_Class)
  212.     {
  213.       case HKCLASS_RAWKEY:
  214.       case HKCLASS_RAWMOUSE:
  215.         ret = ConvertCode(ykd->ykd_Code, codestr);
  216.         break;
  217.  
  218.       case HKCLASS_DISKINSERTED:
  219.       case HKCLASS_DISKREMOVED:
  220.         codestr[0]='\0';
  221.         ret = TRUE;
  222.         break;
  223.     }
  224.  
  225.     stpcpy(desc, ClassArray[ykd->ykd_Class]);
  226.     strcat(desc, qualstr);
  227.     strcat(desc, StrokeArray[ykd->ykd_Stroke]);
  228.     strcat(desc, codestr);
  229.  
  230.     return ret;
  231.  
  232. }
  233.  
  234.  
  235.  
  236. __regargs LONG
  237. ParseKeyDef(STRPTR desc, YakKeyDef *ykd)
  238. {
  239.     IX   ix;
  240.     LONG ret;
  241.  
  242.  
  243.     if (!(ret=CompatibleParseIX(desc, &ix)))
  244.     {
  245.         /* Class ? */
  246.         if (ParentWindowID != MCYCLING_WINDOW)
  247.         {
  248.             switch(ix.ix_Class)
  249.             {
  250.               case IECLASS_RAWKEY:
  251.                 ykd->ykd_Class = HKCLASS_RAWKEY;
  252.                 break;
  253.               case IECLASS_RAWMOUSE:
  254.                 ykd->ykd_Class = HKCLASS_RAWMOUSE;
  255.                 break;
  256.               case IECLASS_DISKINSERTED:
  257.                 ykd->ykd_Class = HKCLASS_DISKINSERTED;
  258.                 break;
  259.               case IECLASS_DISKREMOVED:
  260.                 ykd->ykd_Class = HKCLASS_DISKREMOVED;
  261.                 break;
  262.               default:
  263.                 return -1;
  264.             }
  265.         }
  266.         else
  267.         {
  268.             if (ix.ix_Class == IECLASS_RAWMOUSE)
  269.                 ykd->ykd_Class = HKCLASS_RAWMOUSE;
  270.             else
  271.                 return -1;
  272.         }
  273.  
  274.         /* Qualifier ? */
  275.         ykd->ykd_Qual  =  ix.ix_Qualifier;
  276.         ykd->ykd_IQual = ~ix.ix_QualMask;
  277.  
  278.         ykd->ykd_SQual = NO_IEQUALIFIER;
  279.         if (ix.ix_QualSame & IXSYM_SHIFT) ykd->ykd_SQual |= IXSYM_SHIFTMASK;
  280.         if (ix.ix_QualSame & IXSYM_CAPS)  ykd->ykd_SQual |= IXSYM_CAPSMASK;
  281.         if (ix.ix_QualSame & IXSYM_ALT)   ykd->ykd_SQual |= IXSYM_ALTMASK;
  282.  
  283.         /* Stroke ? */
  284.         if (ix.ix_Code & IECODE_UP_PREFIX)
  285.         {
  286.             ykd->ykd_Stroke = HKSTROKE_UP;
  287.         }
  288.         else
  289.         {
  290.             if (~ix.ix_CodeMask & IECODE_UP_PREFIX)
  291.             {
  292.                 ykd->ykd_Stroke = HKSTROKE_DOWN_UP;
  293.             }
  294.             else
  295.             {
  296.                 ykd->ykd_Stroke = HKSTROKE_DOWN;
  297.             }
  298.         }
  299.  
  300.         /* Code ? */
  301.         if (!ix.ix_Code && (ix.ix_Class == IECLASS_RAWMOUSE))
  302.         {
  303.             ykd->ykd_Code = NO_IECODE;
  304.         }
  305.         else
  306.         {
  307.             ykd->ykd_Code = ix.ix_Code & ~IECODE_UP_PREFIX;
  308.         }
  309.     }
  310.     else
  311.     {
  312.         if (ret == -2)          /* NULL description */
  313.         {
  314.             if (ParentWindowID == MCYCLING_WINDOW)
  315.             {
  316.                 ykd->ykd_Class  = HKCLASS_RAWMOUSE;
  317.                 ykd->ykd_Qual   = ykd->ykd_IQual = ykd->ykd_SQual = NO_IEQUALIFIER;
  318.                 ykd->ykd_Stroke = HKSTROKE_DOWN;
  319.                 ykd->ykd_Code   = NO_IECODE;
  320.             }
  321.             else
  322.             {
  323.                 ykd->ykd_Class  = HKCLASS_RAWKEY;
  324.                 ykd->ykd_Qual   = ykd->ykd_IQual = ykd->ykd_SQual = NO_IEQUALIFIER;
  325.                 ykd->ykd_Stroke = HKSTROKE_DOWN;
  326.                 ykd->ykd_Code   = NO_IECODE;
  327.             }
  328.         }
  329.     }
  330.  
  331.     return ret;
  332. }
  333.  
  334. __regargs UWORD
  335. IsQualifierPad(UWORD code)
  336. {
  337.     UWORD i;
  338.  
  339.     for (i=0; i<QUALIFIERSPAD_NUMBER; i++)
  340.         if (QualifierPadArray[i].qpat_Code == code)
  341.             return QualifierPadArray[i].qpat_Qualifier;
  342.  
  343.     return NO_IEQUALIFIER;
  344. }
  345.